package org.convallaria.framework.common.constants.sys;

/**
 * 数据字典相关常量
 * 
 * 功能特性：
 * - 定义字典状态常量
 * - 定义字典字段长度限制
 * - 提供统一的常量管理
 * 
 * 设计原则：
 * - 所有常量都是public static final
 * - 使用final类防止继承
 * - 私有构造函数防止实例化
 * - 按功能模块分组组织
 * 
 * @author convallaria
 * @since 1.0.0
 */
public final class DictConstants {

    private DictConstants() {
        // 防止实例化
    }

    // ==================== 字典状态常量 ====================

    /**
     * 字典正常状态
     */
    public static final String DICT_STATUS_NORMAL = "0";

    /**
     * 字典停用状态
     */
    public static final String DICT_STATUS_DISABLED = "1";

    // ==================== 默认值常量 ====================

    /**
     * 是否默认 - 是
     */
    public static final String IS_DEFAULT_YES = "Y";

    /**
     * 是否默认 - 否
     */
    public static final String IS_DEFAULT_NO = "N";

    // ==================== 字典字段长度限制 ====================

    /**
     * 字典名称最大长度
     */
    public static final int DICT_NAME_MAX_LENGTH = 100;

    /**
     * 字典类型最大长度
     */
    public static final int DICT_TYPE_MAX_LENGTH = 100;

    /**
     * 字典标签最大长度
     */
    public static final int DICT_LABEL_MAX_LENGTH = 100;

    /**
     * 字典键值最大长度
     */
    public static final int DICT_VALUE_MAX_LENGTH = 100;

    /**
     * CSS类名最大长度
     */
    public static final int CSS_CLASS_MAX_LENGTH = 100;

    /**
     * 列表样式最大长度
     */
    public static final int LIST_CLASS_MAX_LENGTH = 100;

    /**
     * 备注最大长度
     */
    public static final int REMARK_MAX_LENGTH = 500;

    /**
     * 字典排序最小值
     */
    public static final int DICT_SORT_MIN = 0;

    /**
     * 字典排序最大值
     */
    public static final int DICT_SORT_MAX = 999;

    // ==================== 字典状态描述 ====================

    /**
     * 字典状态描述映射
     */
    public static final String[] DICT_STATUS_DESCRIPTIONS = {
        "正常", "停用"
    };

    /**
     * 是否默认描述映射
     */
    public static final String[] IS_DEFAULT_DESCRIPTIONS = {
        "否", "是"
    };

    // ==================== 默认值常量 ====================

    /**
     * 默认字典状态
     */
    public static final String DEFAULT_DICT_STATUS = DICT_STATUS_NORMAL;

    /**
     * 默认是否默认
     */
    public static final String DEFAULT_IS_DEFAULT = IS_DEFAULT_NO;

    /**
     * 默认字典排序
     */
    public static final int DEFAULT_DICT_SORT = 0;

    // ==================== 业务规则常量 ====================

    /**
     * 字典类型正则表达式（字母、数字、下划线、连字符）
     */
    public static final String DICT_TYPE_PATTERN = "^[a-zA-Z0-9_-]+$";

    /**
     * 字典标签正则表达式（中文、字母、数字、下划线、连字符、空格、括号）
     */
    public static final String DICT_LABEL_PATTERN = "^[\\u4e00-\\u9fa5a-zA-Z0-9_\\-\\s()（）]+$";

    /**
     * 字典键值正则表达式（字母、数字、下划线、连字符、点号）
     */
    public static final String DICT_VALUE_PATTERN = "^[a-zA-Z0-9._-]+$";

    /**
     * CSS类名正则表达式（字母、数字、下划线、连字符）
     */
    public static final String CSS_CLASS_PATTERN = "^[a-zA-Z0-9_-]+$";

    /**
     * 列表样式正则表达式（字母、数字、下划线、连字符）
     */
    public static final String LIST_CLASS_PATTERN = "^[a-zA-Z0-9_-]+$";

    // ==================== 常用字典类型常量 ====================

    /**
     * 系统状态字典类型
     */
    public static final String DICT_TYPE_SYSTEM_STATUS = "sys_status";

    /**
     * 用户状态字典类型
     */
    public static final String DICT_TYPE_USER_STATUS = "user_status";

    /**
     * 用户类型字典类型
     */
    public static final String DICT_TYPE_USER_TYPE = "user_type";

    /**
     * 性别字典类型
     */
    public static final String DICT_TYPE_USER_SEX = "user_sex";

    /**
     * 部门状态字典类型
     */
    public static final String DICT_TYPE_DEPT_STATUS = "dept_status";

    /**
     * 岗位状态字典类型
     */
    public static final String DICT_TYPE_POST_STATUS = "post_status";

    /**
     * 角色状态字典类型
     */
    public static final String DICT_TYPE_ROLE_STATUS = "role_status";

    /**
     * 数据范围字典类型
     */
    public static final String DICT_TYPE_DATA_SCOPE = "data_scope";

    /**
     * 菜单类型字典类型
     */
    public static final String DICT_TYPE_MENU_TYPE = "menu_type";

    /**
     * 菜单状态字典类型
     */
    public static final String DICT_TYPE_MENU_STATUS = "menu_status";

    /**
     * 配置类型字典类型
     */
    public static final String DICT_TYPE_CONFIG_TYPE = "config_type";

    /**
     * 登录状态字典类型
     */
    public static final String DICT_TYPE_LOGIN_STATUS = "login_status";

    /**
     * 操作状态字典类型
     */
    public static final String DICT_TYPE_OPER_STATUS = "oper_status";

    /**
     * 业务类型字典类型
     */
    public static final String DICT_TYPE_BUSINESS_TYPE = "business_type";

    // ==================== 工具方法 ====================

    /**
     * 获取字典状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    public static String getDictStatusDesc(String status) {
        if (DICT_STATUS_NORMAL.equals(status)) {
            return DICT_STATUS_DESCRIPTIONS[0];
        } else if (DICT_STATUS_DISABLED.equals(status)) {
            return DICT_STATUS_DESCRIPTIONS[1];
        }
        return "未知";
    }

    /**
     * 获取是否默认描述
     * 
     * @param isDefault 是否默认值
     * @return 是否默认描述
     */
    public static String getIsDefaultDesc(String isDefault) {
        if (IS_DEFAULT_NO.equals(isDefault)) {
            return IS_DEFAULT_DESCRIPTIONS[0];
        } else if (IS_DEFAULT_YES.equals(isDefault)) {
            return IS_DEFAULT_DESCRIPTIONS[1];
        }
        return "未知";
    }

    /**
     * 验证字典状态是否有效
     * 
     * @param status 状态值
     * @return true=有效，false=无效
     */
    public static boolean isValidDictStatus(String status) {
        return DICT_STATUS_NORMAL.equals(status) || DICT_STATUS_DISABLED.equals(status);
    }

    /**
     * 验证是否默认值是否有效
     * 
     * @param isDefault 是否默认值
     * @return true=有效，false=无效
     */
    public static boolean isValidIsDefault(String isDefault) {
        return IS_DEFAULT_YES.equals(isDefault) || IS_DEFAULT_NO.equals(isDefault);
    }

    /**
     * 验证字典名称是否有效
     * 
     * @param dictName 字典名称
     * @return true=有效，false=无效
     */
    public static boolean isValidDictName(String dictName) {
        if (dictName == null || dictName.trim().isEmpty()) {
            return false;
        }
        return dictName.length() <= DICT_NAME_MAX_LENGTH;
    }

    /**
     * 验证字典类型是否有效
     * 
     * @param dictType 字典类型
     * @return true=有效，false=无效
     */
    public static boolean isValidDictType(String dictType) {
        if (dictType == null || dictType.trim().isEmpty()) {
            return false;
        }
        if (dictType.length() > DICT_TYPE_MAX_LENGTH) {
            return false;
        }
        return dictType.matches(DICT_TYPE_PATTERN);
    }

    /**
     * 验证字典标签是否有效
     * 
     * @param dictLabel 字典标签
     * @return true=有效，false=无效
     */
    public static boolean isValidDictLabel(String dictLabel) {
        if (dictLabel == null || dictLabel.trim().isEmpty()) {
            return false;
        }
        if (dictLabel.length() > DICT_LABEL_MAX_LENGTH) {
            return false;
        }
        return dictLabel.matches(DICT_LABEL_PATTERN);
    }

    /**
     * 验证字典键值是否有效
     * 
     * @param dictValue 字典键值
     * @return true=有效，false=无效
     */
    public static boolean isValidDictValue(String dictValue) {
        if (dictValue == null || dictValue.trim().isEmpty()) {
            return false;
        }
        if (dictValue.length() > DICT_VALUE_MAX_LENGTH) {
            return false;
        }
        return dictValue.matches(DICT_VALUE_PATTERN);
    }

    /**
     * 验证字典排序是否有效
     * 
     * @param dictSort 字典排序
     * @return true=有效，false=无效
     */
    public static boolean isValidDictSort(Integer dictSort) {
        if (dictSort == null) {
            return false;
        }
        return dictSort >= DICT_SORT_MIN && dictSort <= DICT_SORT_MAX;
    }

    /**
     * 验证CSS类名是否有效
     * 
     * @param cssClass CSS类名
     * @return true=有效，false=无效
     */
    public static boolean isValidCssClass(String cssClass) {
        if (cssClass == null || cssClass.trim().isEmpty()) {
            return true; // CSS类名可以为空
        }
        if (cssClass.length() > CSS_CLASS_MAX_LENGTH) {
            return false;
        }
        return cssClass.matches(CSS_CLASS_PATTERN);
    }

    /**
     * 验证列表样式是否有效
     * 
     * @param listClass 列表样式
     * @return true=有效，false=无效
     */
    public static boolean isValidListClass(String listClass) {
        if (listClass == null || listClass.trim().isEmpty()) {
            return true; // 列表样式可以为空
        }
        if (listClass.length() > LIST_CLASS_MAX_LENGTH) {
            return false;
        }
        return listClass.matches(LIST_CLASS_PATTERN);
    }

    /**
     * 判断是否为默认字典项
     * 
     * @param isDefault 是否默认值
     * @return true=默认，false=非默认
     */
    public static boolean isDefault(String isDefault) {
        return IS_DEFAULT_YES.equals(isDefault);
    }

    /**
     * 判断是否为非默认字典项
     * 
     * @param isDefault 是否默认值
     * @return true=非默认，false=默认
     */
    public static boolean isNotDefault(String isDefault) {
        return IS_DEFAULT_NO.equals(isDefault);
    }

    /**
     * 清理字典类型（转换为小写）
     * 
     * @param dictType 原始字典类型
     * @return 清理后的字典类型
     */
    public static String cleanDictType(String dictType) {
        if (dictType == null) {
            return "";
        }
        return dictType.trim().toLowerCase();
    }

    /**
     * 清理字典标签（去除多余空格）
     * 
     * @param dictLabel 原始字典标签
     * @return 清理后的字典标签
     */
    public static String cleanDictLabel(String dictLabel) {
        if (dictLabel == null) {
            return "";
        }
        return dictLabel.trim().replaceAll("\\s+", " ");
    }

    /**
     * 清理字典键值（转换为小写）
     * 
     * @param dictValue 原始字典键值
     * @return 清理后的字典键值
     */
    public static String cleanDictValue(String dictValue) {
        if (dictValue == null) {
            return "";
        }
        return dictValue.trim().toLowerCase();
    }
}
